import java.util.Arrays;
import java.util.Scanner;

public class TestDemo {
    //数组逆序

    //思路
    //设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素.
    //然后让前一个下标自增, 后一个下标自减, 循环继续即可.
    public static void reverase(int[] array){
        int left = 0;
        int right = array.length - 1;
        while(left < right){
            int tmp = array[left];
            array[left] = array[right];
            array[right] = tmp;
            left++;
            right--;
        }
    }
    public static void main1(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n= sc.nextInt();
        int[] array = new int[n];
        for (int i = 0; i < array.length; i++) {
            array[i] = sc.nextInt();
        }
        reverase(array);
        System.out.println(Arrays.toString(array));
    }

    //二维数组
    //数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };
    public static void main2(String[] args) {
        //在Java中我们需要分行去定义，那么就是说{{1，2，3}，{4，5，6}，{7，8，9}}
        //这其中{1，2，3}等都是一行的数字
        int[][] array1 = {{1,2,3},{4,5,6},{7,8,9}};//第一种定义
        int[][] array2 = new int[][]{{1,2,3},{4,5,6},{7,8,9}};//这个时候我们不在[][]不能写
        int[][] array3 = new int[2][3];//这个时候不能定义{}（大括号），这个时候全是默认的0；
        //array[行的坐标][列的坐标]
        //遍历数组
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(array1[i][j] + " ");
            }
            System.out.println();
        }
    }
    //二维数组是一种特殊的一维数组，这一点在Java中体现得淋漓尽致
    //在Java中的二维数组，会有i行j列，那么每行获得的地址是不同的
    //假设有2行3列的二维数组，那么我们就会发现两行的元素所存的地址是不同的
    //array1 = {{1,2,3},{4,5,6}}
    //第1行，地址位0x123，那么通过虚拟机栈指向堆中的对象{1，2，3}
    //第2行也是如此，它的地址为0x1423，那么通过虚拟机栈指向堆中的对象{4，5，6}
    //所以我们发现了在二维数组中有两个地址，那就表明了我们可以理解为一个特殊的一维数组。

    public static void main3(String[] args) {
        int[][] array1 = {{1,2,3},{4,5,6}};
        System.out.println(array1[0]);
        System.out.println(array1[1]);
//        System.out.println("================");
//        System.out.println(Arrays.toString(array1[0]));
//        System.out.println(Arrays.toString(array1[1]));
//        System.out.println("================");
//        System.out.println(array1[0].length);//一行元素的长度
//        System.out.println(array1[1].length);//一行元素的长度
//        //所以我们可以理解为是两个一维数组array[0],array[1]
//        System.out.println("================");
//        System.out.println(array1.length);//这个表示有多少行
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                System.out.print(array1[i][j] + " ");
            }
            System.out.println();
        }

        //利用将其转化为字符串来进行打印
        String ret = Arrays.deepToString(array1);
        //我们需要进行深度打印，在tostring前面加上了deep即可
        System.out.println(ret);
    }

    //不规则二维数组
    public static void main4(String[] args){
        int[][] array = new int[2][];
        //二维数组在Java中我们可以去不用定义列,所以我们可以省略列的定义

        //其实我们可以对行元素去进行一维数组的定义
        array[0] = new int[]{1,2,3};
        array[1] = new int[]{4,5,6,7,8,9};
        //上述这个操作，可指定某一行元素是为不规则的，但是我们不用去定义列
        System.out.println(Arrays.deepToString(array));
    }

    public static void main(String[] args) {
        int[][] array = new int[2][];
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
        //上述我们出现空指针的错误 NullPointerException
        //因为我们知道了在二维数组中的行的定义是存储地址，通过地址指向在行中定义的列的元素。
        //因为没有定义列，所以在行的定义它就会存不到地址

        //初始化没有赋值，那么它就会出现了野指针


        //最重要的是内存布局，引用，Arrays的工具类
    }
}
